--- title: Examples keywords: fastai sidebar: home_sidebar summary: "Some circuits, protocols and sampling" description: "Some circuits, protocols and sampling" nb_path: "08_examples.ipynb" ---
{% raw %}
{% endraw %} {% raw %}
{% endraw %}

Circuits

{% raw %}
{% endraw %} {% raw %} 
ghz.draw()
{% endraw %} {% raw %}
{% endraw %} {% raw %} 
ghz_stabs.draw(scale=1.2)
{% endraw %} {% raw %}
{% endraw %} {% raw %} 
eft.draw(scale=1.5)
{% endraw %} {% raw %}
{% endraw %} {% raw %} 
sz_123.draw()
{% endraw %} {% raw %}
{% endraw %} {% raw %} 
meas7.draw(scale=1.2)
{% endraw %} {% raw %}
{% endraw %} {% raw %} 
nfs.draw(scale=1)
{% endraw %}

Protocols

GHZ repeat until success protocol

  • Repeat GHZ preparation circuit for a maximum of 3 times.
  • Only repeat if a measurement yields 1, i.e. the flag has been triggered.
  • If we measure in all 3 runs three times 1, count a logical failure.
  • In all other cases the protocol completed without logical failure.
{% raw %}

gen_ghz3[source]

gen_ghz3()

{% endraw %} {% raw %}
{% endraw %} {% raw %} 
ghz3.draw(figsize=(6,6))
{% endraw %}

GHZ stabilizer measurement

  • Prepare GHZ state with flag measurement 0. (If 1 is measured repeat preparation as often as necessary)
  • Reset ancilla and measure the stabilizers of the GHZ state (without noise). The stabilizers are:
    • One XXXX stab
    • and three ZZ stabs
  • Use syndrom from stabilizer measurements to lookup and perform the correction.
  • Measure stabilizers again.
  • Now we have a logical failure if this measurement gives us any syndrome, i.e. if the measurement is anything other than four 0s.
{% raw %}

gen_ghz_stab[source]

gen_ghz_stab()

{% endraw %} {% raw %}
{% endraw %} {% raw %} 
ghz_stab.draw(figsize=(6,6), legend=True)
{% endraw %}

Fault-tolerant color code flag protocol

  • ...
{% raw %}

gen_ftsteane[source]

gen_ftsteane()

{% endraw %} {% raw %}
{% endraw %} {% raw %} 
ftsteane.draw(figsize=(8,6), label_offset=(0,0.15))
{% endraw %}

Det. Steane logical 0 preparation protocol

{% raw %}

gen_steane0[source]

gen_steane0()

{% endraw %} {% raw %}
{% endraw %} {% raw %} 
steane0.draw(figsize=(6,6), legend=True)
{% endraw %}

Flag stabilizer protocol

  • ...
{% raw %}

gen_flagstab[source]

gen_flagstab()

{% endraw %} {% raw %}
{% endraw %} {% raw %} 
flagstab.draw(legend=True, figsize=(15,5))
{% endraw %}

Samplings

{% raw %} 
from qsam.sampler.direct import DirectSampler
from qsam.sampler.subset import SubsetSampler
from qsam.noise import E1
from qsam.callbacks import *

from qsam.sim.stabilizer import StabilizerSimulator as CHP
import numpy as np
{% endraw %}

Use same error parameters for all examplatory samplings.

{% raw %} 
sample_range = np.logspace(-3,0,5)
err_probs = {'q': sample_range}
pmax = {'q': 0.1}
{% endraw %}

GHZ repeat until success

{% raw %} 
from qsam.sampler.base import protocol_subset_occurence, protocol_all_subsets, err_probs_tomatrix
import matplotlib.pyplot as plt

e = E1()
x = err_probs_tomatrix({'q': np.logspace(-3,0,100)}, ['q'])
grps = {grp: e.group(circuit) for grp, circuit in ghz3._circuits.items()}
wgts_combis = protocol_all_subsets(grps)
Aws = protocol_subset_occurence(grps, wgts_combis, x)

for circ_Aws in Aws.values():
    plt.figure()
    for name, y in circ_Aws.items():
        plt.loglog(x, y, label=name)
    plt.legend()
{% endraw %} {% raw %} 
mc_sam = DirectSampler(ghz3, CHP, err_probs=err_probs, err_model=E1)
mc_sam.run(10000, callbacks=[])
{% endraw %} {% raw %} 
ss_sam = SubsetSampler(ghz3, CHP,  pmax=pmax, err_probs=err_probs, err_model=E1)
ss_sam.run(1000, callbacks=[])
ss_sam.tree.draw()
{% endraw %} {% raw %} 
import matplotlib.pyplot as plt

p_L, std = mc_sam.stats()
p_L_low, ss_std_low, p_L_up, ss_std_up = ss_sam.stats()

plt.errorbar(sample_range, p_L, fmt='--', c="black", yerr=std, label="Direct MC")
plt.loglog(sample_range, p_L_low, label='SS low')
plt.fill_between(sample_range, p_L_low-ss_std_low, p_L_low+ss_std_low, alpha=0.2)
plt.loglog(sample_range, p_L_up, label='SS low')
plt.fill_between(sample_range, p_L_up-ss_std_up, p_L_up+ss_std_up, alpha=0.2)

<matplotlib.collections.PolyCollection at 0x7ff256374400>
{% endraw %}

GHZ stab

{% raw %} 
protocol = ghz_stab

from qsam.sampler.base import protocol_subset_occurence, protocol_all_subsets, err_probs_tomatrix
import matplotlib.pyplot as plt

e = E1()
x = err_probs_tomatrix({'q': np.logspace(-3,0,100)}, ['q'])
grps = {grp: e.group(circuit) for grp, circuit in protocol._circuits.items()}
wgts_combis = protocol_all_subsets(grps)
Aws = protocol_subset_occurence(grps, wgts_combis, x)

for circ_Aws in Aws.values():
    plt.figure()
    for name, y in circ_Aws.items():
        plt.loglog(x, y, label=name)
    plt.legend()
{% endraw %} {% raw %} 
mc_sam = DirectSampler(ghz_stab, CHP, err_probs=err_probs, err_model=E1)
mc_sam.run(10000, callbacks=[])
{% endraw %} {% raw %} 
ss_sam = SubsetSampler(ghz_stab, CHP, pmax=pmax, err_probs=err_probs, err_model=E1)
ss_sam.run(1000, callbacks=[])
ss_sam.tree.draw()
{% endraw %} {% raw %} 
import matplotlib.pyplot as plt

p_L, std = mc_sam.stats()
p_L_low, ss_std_low, p_L_up, ss_std_up = ss_sam.stats()

plt.errorbar(sample_range, p_L, fmt='--', c="black", yerr=std, label="Direct MC")
plt.loglog(sample_range, p_L_low, label='SS low')
plt.fill_between(sample_range, p_L_low-ss_std_low, p_L_low+ss_std_low, alpha=0.2)
plt.loglog(sample_range, p_L_up, label='SS low')
plt.fill_between(sample_range, p_L_up-ss_std_up, p_L_up+ss_std_up, alpha=0.2)

<matplotlib.collections.PolyCollection at 0x7ff255da0e80>
{% endraw %}

FT Steane

{% raw %} 
protocol = ftsteane

from qsam.sampler.base import protocol_subset_occurence, protocol_all_subsets, err_probs_tomatrix
import matplotlib.pyplot as plt

e = E1()
x = err_probs_tomatrix({'q': np.logspace(-3,0,100)}, ['q'])
grps = {grp: e.group(circuit) for grp, circuit in protocol._circuits.items()}
wgts_combis = protocol_all_subsets(grps)
Aws = protocol_subset_occurence(grps, wgts_combis, x)

for circ_Aws in Aws.values():
    plt.figure()
    for name, y in circ_Aws.items():
        plt.loglog(x, y, label=name)
    plt.legend()
{% endraw %} {% raw %} 
mc_sam = DirectSampler(ftsteane, CHP,  err_probs=err_probs, err_model=E1)
mc_sam.run(10000, callbacks=[])
{% endraw %} {% raw %} 
from qsam.callbacks import *

ss_sam = SubsetSampler(ftsteane, CHP, pmax={"q": 0.01}, err_probs=err_probs, err_model=E1)
ss_sam.run(5000, callbacks=[])
ss_sam.tree.draw()
{% endraw %} {% raw %} 
import matplotlib.pyplot as plt

p_L, std = mc_sam.stats()
p_L_low, ss_std_low, p_L_up, ss_std_up = ss_sam.stats()

plt.errorbar(sample_range, p_L, fmt='--', c="black", yerr=std, label="Direct MC")
plt.loglog(sample_range, p_L_low, label='SS low')
plt.fill_between(sample_range, p_L_low-ss_std_low, p_L_low+ss_std_low, alpha=0.2)
plt.loglog(sample_range, p_L_up, label='SS low')
plt.fill_between(sample_range, p_L_up-ss_std_up, p_L_up+ss_std_up, alpha=0.2)

<matplotlib.collections.PolyCollection at 0x7ff254e4d7b0>
{% endraw %} {% raw %} 
plt.loglog(sample_range,ss_std_low)
plt.loglog(sample_range,ss_std_up)

[<matplotlib.lines.Line2D at 0x7ff2548553f0>]
{% endraw %}

Steane FT logical-0

{% raw %} 
protocol = steane0

from qsam.sampler.base import protocol_subset_occurence, protocol_all_subsets, err_probs_tomatrix
import matplotlib.pyplot as plt

e = E1()
x = err_probs_tomatrix({'q': np.logspace(-3,0,100)}, ['q'])
grps = {grp: e.group(circuit) for grp, circuit in protocol._circuits.items()}
wgts_combis = protocol_all_subsets(grps)
Aws = protocol_subset_occurence(grps, wgts_combis, x)

for circ_Aws in Aws.values():
    plt.figure()
    for name, y in circ_Aws.items():
        plt.loglog(x, y, label=name)
    plt.legend()
{% endraw %} {% raw %} 
mc_sam = DirectSampler(steane0, CHP, err_probs=err_probs, err_model=E1)
mc_sam.run(20000, callbacks=[])
{% endraw %} {% raw %} 
ss_sam = SubsetSampler(steane0, CHP, pmax=pmax, err_probs=err_probs, err_model=E1)
ss_sam.run(1000, callbacks=[])
ss_sam.tree.draw()
{% endraw %} {% raw %} 
import matplotlib.pyplot as plt

p_L, std = mc_sam.stats()
p_L_low, ss_std_low, p_L_up, ss_std_up = ss_sam.stats()

plt.errorbar(sample_range, p_L, fmt='--', c="black", yerr=std, label="Direct MC")
plt.loglog(sample_range, p_L_low, label='SS low')
plt.fill_between(sample_range, p_L_low-ss_std_low, p_L_low+ss_std_low, alpha=0.2)
plt.loglog(sample_range, p_L_up, label='SS low')
plt.fill_between(sample_range, p_L_up-ss_std_up, p_L_up+ss_std_up, alpha=0.2)
{% endraw %}

Flagstab

{% raw %} 
protocol = flagstab

from qsam.sampler.base import protocol_subset_occurence, protocol_all_subsets, err_probs_tomatrix
import matplotlib.pyplot as plt

e = E1()
x = err_probs_tomatrix({'q': np.logspace(-3,0,100)}, ['q'])
grps = {grp: e.group(circuit) for grp, circuit in protocol._circuits.items()}
wgts_combis = protocol_all_subsets(grps)
Aws = protocol_subset_occurence(grps, wgts_combis, x)

for circ_Aws in Aws.values():
    plt.figure()
    for name, y in circ_Aws.items():
        plt.loglog(x, y, label=name)
    plt.legend()
{% endraw %} {% raw %} 
mc_sam = DirectSampler(flagstab, CHP, err_probs=err_probs, err_model=E1)
mc_sam.run(10000, callbacks=[])
{% endraw %} {% raw %} 
ss_sam = SubsetSampler(flagstab, CHP, pmax={"q": 0.01}, err_probs=err_probs, err_model=E1)
ss_sam.run(5000, callbacks=[])
ss_sam.tree.draw()
{% endraw %} {% raw %} 
import matplotlib.pyplot as plt

p_L, std = mc_sam.stats()
p_L_low, ss_std_low, p_L_up, ss_std_up = ss_sam.stats()

plt.errorbar(sample_range, p_L, fmt='--', c="black", yerr=std, label="Direct MC")

plt.plot(sample_range, p_L_low, label='SS low')
plt.fill_between(sample_range, p_L_low-ss_std_low, p_L_low+ss_std_low, alpha=0.2)
plt.plot(sample_range, p_L_up, label='SS low')
plt.fill_between(sample_range, p_L_up-ss_std_up, p_L_up+ss_std_up, alpha=0.2)
plt.xscale('log')
plt.yscale('log')
{% endraw %}

More complex noise

{% raw %} 
from qsam.noise import E3, E3_1, E2
from qsam.callbacks import *
{% endraw %} {% raw %} 
pmax = {
    "q1": 0.1,
    "q2": 0.1, 
    "meas": 0.1,
    "idle": 0.01,
    "init": 0.01
}
err_probs = {
    'q1': 0,
    'q2': sample_range,
    'meas': sample_range * 0.1,
    'idle': sample_range * 0.01,
    'init':sample_range * 0.001
}
{% endraw %} {% raw %} 
mc_sam = DirectSampler(ghz3, CHP, err_probs=err_probs, err_model=E3)
mc_sam.run(10000, callbacks=[PlotStats()])
{% endraw %} {% raw %} 
ss_sam = SubsetSampler(ghz3, CHP, pmax=pmax, err_probs=err_probs, err_model=E3)
ss_sam.run(2000, callbacks=[PlotStats()])
ss_sam.tree.draw()
{% endraw %} {% raw %} 
import matplotlib.pyplot as plt

p_L, std = mc_sam.stats()
p_L_low, ss_std_low, p_L_up, ss_std_up = ss_sam.stats()

plt.errorbar(sample_range, p_L, fmt='--', c="black", yerr=std, label="Direct MC")

plt.plot(sample_range, p_L_low, label='SS low')
plt.fill_between(sample_range, p_L_low-ss_std_low, p_L_low+ss_std_low, alpha=0.2)
plt.plot(sample_range, p_L_up, label='SS low')
plt.fill_between(sample_range, p_L_up-ss_std_up, p_L_up+ss_std_up, alpha=0.2)
plt.xscale('log')
plt.yscale('log')
{% endraw %}